import QtQuick 2.12
import QtQuick.Layouts 1.12
import QtQuick.Controls 2.12
import QtGraphicalEffects 1.12
import QtMultimedia 5.12

Rectangle {
    id: remoteControlPage
    color: "transparent"

    // 页面状态
    property bool manualMode: false // false: 参数预设自动运行, true: 远程手动控制
    // 监控区交互：聚焦的摄像头 (""/"front"/"rear")
    property string focusedCamera: ""
    
    // 添加键盘事件处理
    property bool keysEnabled: false
    
    // 紧急停止控制状态变量
    property int emergencyStopStep: 0  // 当前紧急停止执行步骤
    property bool isEmergencyStopping: false  // 是否正在执行紧急停止
    
    // 定时器用于紧急停止延迟执行
    Timer {
        id: emergencyStopTimer
        interval: 1000  // 1秒延迟
        repeat: false
        onTriggered: {
            console.log("紧急停止定时器触发，当前步骤:", emergencyStopStep)
            executeNextEmergencyStopStep()
        }
    }
    
    // 执行紧急停止的下一步骤
    function executeNextEmergencyStopStep() {
        if (emergencyStopStep >= 8) {
            // 所有步骤执行完成
            console.log("紧急停止执行完成：所有设备已置0，控制权限保留")
            isEmergencyStopping = false
            emergencyStopStep = 0
            return true  // 返回true表示完成
        }
        
        console.log("执行紧急停止步骤 " + (emergencyStopStep + 1) + "/8")
        
        switch(emergencyStopStep) {
            case 0:
                // 转向控制置0
                sendSteeringControlCommand(0)
                break
            case 1:
                // 行进控制置0
                sendMovementControlCommand(0)
                break
            case 2:
                // 发电机启动控制置0
                sendGeneratorControlCommand(0)
                break
            case 3:
                // 220V继电器控制置0
                sendRelayControlCommand(0)
                break
            case 4:
                // 喷水控制置0
                sendSprayControlCommand(0)
                break
            case 5:
                // 制冷自动控制置0
                sendCoolingControlCommand(0)
                break
            case 6:
                // 行进速度百分比控制置0
                sendSpeedControlCommand(0)
                break
            case 7:
                // 割叶机控制置0
                sendCutterControlCommand(0)
                break
        }
        
        emergencyStopStep++
        
        // 如果还有下一步，启动下一个定时器
        if (emergencyStopStep < 8) {
            emergencyStopTimer.start()
            return false  // 返回false表示还有后续步骤
        } else {
            // 所有步骤执行完成
            console.log("紧急停止执行完成：所有设备已置0，控制权限保留")
            isEmergencyStopping = false
            emergencyStopStep = 0
            return true  // 返回true表示完成
        }
    }

    // 启动紧急停止流程 (供C++调用)
    function startEmergencyStop() {
        if (isEmergencyStopping) {
            console.log("紧急停止已在执行中，忽略重复请求")
            return false
        }
        
        console.log("C++代码请求启动紧急停止流程")
        isEmergencyStopping = true
        emergencyStopStep = 0
        
        // 开始执行紧急停止流程
        emergencyStopTimer.start()
        return true
    }
    
    // 组件初始化调试
    Component.onCompleted: {
        console.log("RemoteControlPage: Component completed successfully")
        console.log("RemoteControlPage: manualMode =", manualMode)
    }
    
    // 页面激活时调用的函数
    function onPageActivated() {
        console.log("RemoteControlPage: 页面已激活")
        // 向当前选中的下位机发送请求RTSP地址的JSON数据包
        requestRTSPAddresses()
    }

    // 发送平台遥控模式指令函数（参数化版本）
    function sendPlatformRemoteModeCommand(commandValue) {
        console.log("RemoteControlPage: 发送平台遥控模式指令，指令值:", commandValue)
        
        // 检查当前机器人是否可用
        if (typeof mainWindow === 'undefined' || !mainWindow.currentRobot) {
            console.log("无法发送平台遥控模式指令：currentRobot不可用")
            return
        }
        
        // 创建平台遥控模式指令（寄存器地址120，功能码6）
        var platformCommand = {
            "robot_sn": mainWindow.currentRobot,  // 下位机要求的设备SN字段
            "command": {
                "rawCommands": [{
                    "address": 120,      // 寄存器地址120
                    "value": commandValue, // 指令值（1为平台遥控模式，0为权限释放）
                    "functionCode": 6    // 功能码6（写单个寄存器）
                }]
            }
        }
        
        // 通过robotManager发送命令
        if (typeof robotManager !== 'undefined') {
            // 记录日志
            logControlCommand(platformCommand, mainWindow.currentRobot)
            
            // 发送命令到机器人
            robotManager.sendControlCommand(mainWindow.currentRobot, platformCommand)
            console.log("RemoteControlPage: 平台遥控模式指令已发送，指令值:", commandValue)
        } else {
            console.log("无法发送平台遥控模式指令：robotManager不可用")
        }
    }

    // 发送平台遥控权限释放指令函数
    function sendPlatformRemoteReleaseCommand() {
        console.log("RemoteControlPage: 发送平台遥控权限释放指令")
        sendPlatformRemoteModeCommand(0)
    }

    // 发送控速指令函数 (D127 127 06/10)
    function sendSpeedControlCommand(speedValue) {
        console.log("RemoteControlPage: 发送控速指令，指令值:", speedValue)
        
        // 检查当前机器人是否可用
        if (typeof mainWindow === 'undefined' || !mainWindow.currentRobot) {
            console.log("无法发送控速指令：currentRobot不可用")
            return
        }
        
        // 创建控速指令（寄存器地址127，功能码6）
        var speedCommand = {
            "robot_sn": mainWindow.currentRobot,  // 下位机要求的设备SN字段
            "command": {
                "rawCommands": [{
                    "address": 127,      // 寄存器地址127
                    "value": speedValue, // 指令值（0-50百分比控制）
                    "functionCode": 6    // 功能码6（写单个寄存器）
                }]
            }
        }
        
        // 通过robotManager发送命令
        if (typeof robotManager !== 'undefined') {
            // 记录日志
            logControlCommand(speedCommand, mainWindow.currentRobot)
            
            // 发送命令到机器人
            robotManager.sendControlCommand(mainWindow.currentRobot, speedCommand)
            console.log("RemoteControlPage: 控速指令已发送，指令值:", speedValue)
        } else {
            console.log("无法发送控速指令：robotManager不可用")
        }
    }

    // 为各个控制地址创建独立的发送指令函数 (与sendSpeedControlCommand格式一致)
    
    /**
     * 发送转向控制指令 (D121)
     * @param {number} value - 转向控制值（负12到12）
     */
    function sendSteeringControlCommand(value) {
        console.log("RemoteControlPage: 发送转向控制指令，指令值:", value)
        
        if (!mainWindow.currentRobot) {
            console.log("无法发送转向控制指令：currentRobot不可用")
            return
        }
        
        var steeringCommand = {
            "robot_sn": mainWindow.currentRobot,
            "command": {
                "rawCommands": [{
                    "address": 121,      // 寄存器地址121
                    "value": value,      // 转向控制值
                    "functionCode": 6    // 功能码6
                }]
            }
        }
        
        if (robotManager) {
            logControlCommand(steeringCommand, mainWindow.currentRobot)
            robotManager.sendControlCommand(mainWindow.currentRobot, steeringCommand)
            console.log("RemoteControlPage: 转向控制指令已发送，指令值:", value)
        } else {
            console.log("无法发送转向控制指令：robotManager不可用")
        }
    }

    /**
     * 发送行进控制指令 (D122)
     * @param {number} value - 行进控制值（负25到25）
     */
    function sendMovementControlCommand(value) {
        console.log("RemoteControlPage: 发送行进控制指令，指令值:", value)
        
        if (!mainWindow.currentRobot) {
            console.log("无法发送行进控制指令：currentRobot不可用")
            return
        }
        
        var movementCommand = {
            "robot_sn": mainWindow.currentRobot,
            "command": {
                "rawCommands": [{
                    "address": 122,      // 寄存器地址122
                    "value": value,      // 行进控制值
                    "functionCode": 6    // 功能码6
                }]
            }
        }
        
        if (robotManager) {
            logControlCommand(movementCommand, mainWindow.currentRobot)
            robotManager.sendControlCommand(mainWindow.currentRobot, movementCommand)
            console.log("RemoteControlPage: 行进控制指令已发送，指令值:", value)
        } else {
            console.log("无法发送行进控制指令：robotManager不可用")
        }
    }

    /**
     * 发送发电机启动控制指令 (D123)
     * @param {number} value - 发电机控制值（0关闭，1启动，2停机）
     */
    function sendGeneratorControlCommand(value) {
        console.log("RemoteControlPage: 发送发电机启动控制指令，指令值:", value)
        
        if (!mainWindow.currentRobot) {
            console.log("无法发送发电机启动控制指令：currentRobot不可用")
            return
        }
        
        var generatorCommand = {
            "robot_sn": mainWindow.currentRobot,
            "command": {
                "rawCommands": [{
                    "address": 123,      // 寄存器地址123
                    "value": value,      // 发电机控制值
                    "functionCode": 6    // 功能码6
                }]
            }
        }
        
        if (robotManager) {
            logControlCommand(generatorCommand, mainWindow.currentRobot)
            robotManager.sendControlCommand(mainWindow.currentRobot, generatorCommand)
            console.log("RemoteControlPage: 发电机启动控制指令已发送，指令值:", value)
        } else {
            console.log("无法发送发电机启动控制指令：robotManager不可用")
        }
    }

    /**
     * 发送220V继电器控制指令 (D124)
     * @param {number} value - 继电器控制值（0关闭，1直接打开）
     */
    function sendRelayControlCommand(value) {
        console.log("RemoteControlPage: 发送220V继电器控制指令，指令值:", value)
        
        if (!mainWindow.currentRobot) {
            console.log("无法发送220V继电器控制指令：currentRobot不可用")
            return
        }
        
        var relayCommand = {
            "robot_sn": mainWindow.currentRobot,
            "command": {
                "rawCommands": [{
                    "address": 124,      // 寄存器地址124
                    "value": value,      // 继电器控制值
                    "functionCode": 6    // 功能码6
                }]
            }
        }
        
        if (robotManager) {
            logControlCommand(relayCommand, mainWindow.currentRobot)
            robotManager.sendControlCommand(mainWindow.currentRobot, relayCommand)
            console.log("RemoteControlPage: 220V继电器控制指令已发送，指令值:", value)
        } else {
            console.log("无法发送220V继电器控制指令：robotManager不可用")
        }
    }

    /**
     * 发送喷水控制指令 (D125)
     * @param {number} value - 喷水控制值（0关闭，1直接打开）
     */
    function sendSprayControlCommand(value) {
        console.log("RemoteControlPage: 发送喷水控制指令，指令值:", value)
        
        if (!mainWindow.currentRobot) {
            console.log("无法发送喷水控制指令：currentRobot不可用")
            return
        }
        
        var sprayCommand = {
            "robot_sn": mainWindow.currentRobot,
            "command": {
                "rawCommands": [{
                    "address": 125,      // 寄存器地址125
                    "value": value,      // 喷水控制值
                    "functionCode": 6    // 功能码6
                }]
            }
        }
        
        if (robotManager) {
            logControlCommand(sprayCommand, mainWindow.currentRobot)
            robotManager.sendControlCommand(mainWindow.currentRobot, sprayCommand)
            console.log("RemoteControlPage: 喷水控制指令已发送，指令值:", value)
        } else {
            console.log("无法发送喷水控制指令：robotManager不可用")
        }
    }

    /**
     * 发送制冷自动控制/手动启动指令 (D126)
     * @param {number} value - 制冷控制值（0关闭，1直接打开，2自动）
     */
    function sendCoolingControlCommand(value) {
        console.log("RemoteControlPage: 发送制冷自动控制/手动启动指令，指令值:", value)
        
        if (!mainWindow.currentRobot) {
            console.log("无法发送制冷自动控制/手动启动指令：currentRobot不可用")
            return
        }
        
        var coolingCommand = {
            "robot_sn": mainWindow.currentRobot,
            "command": {
                "rawCommands": [{
                    "address": 126,      // 寄存器地址126
                    "value": value,      // 制冷控制值
                    "functionCode": 6    // 功能码6
                }]
            }
        }
        
        if (robotManager) {
            logControlCommand(coolingCommand, mainWindow.currentRobot)
            robotManager.sendControlCommand(mainWindow.currentRobot, coolingCommand)
            console.log("RemoteControlPage: 制冷自动控制/手动启动指令已发送，指令值:", value)
        } else {
            console.log("无法发送制冷自动控制/手动启动指令：robotManager不可用")
        }
    }

    /**
     * 发送割叶机控制指令 (D128)
     * @param {number} value - 割叶机控制值（0关闭，1直接打开）
     */
    function sendCutterControlCommand(value) {
        console.log("RemoteControlPage: 发送割叶机控制指令，指令值:", value)
        
        if (!mainWindow.currentRobot) {
            console.log("无法发送割叶机控制指令：currentRobot不可用")
            return
        }
        
        var cutterCommand = {
            "robot_sn": mainWindow.currentRobot,
            "command": {
                "rawCommands": [{
                    "address": 128,      // 寄存器地址128
                    "value": value,      // 割叶机控制值
                    "functionCode": 6    // 功能码6
                }]
            }
        }
        
        if (robotManager) {
            logControlCommand(cutterCommand, mainWindow.currentRobot)
            robotManager.sendControlCommand(mainWindow.currentRobot, cutterCommand)
            console.log("RemoteControlPage: 割叶机控制指令已发送，指令值:", value)
        } else {
            console.log("无法发送割叶机控制指令：robotManager不可用")
        }
    }
    
    // 重试定时器，用于在机器人未准备好时重试请求
    Timer {
        id: retryTimer
        interval: 1000  // 1秒后重试
        repeat: false
        onTriggered: {
            console.log("RemoteControlPage: 重试请求RTSP地址")
            requestRTSPAddresses()
        }
    }
    
    // 请求RTSP地址的函数
    function requestRTSPAddresses() {
        console.log("RemoteControlPage: 请求RTSP地址")
        
        // 检查robotManager、mainWindow和currentRobot是否可用
        if (typeof robotManager !== 'undefined' && typeof mainWindow !== 'undefined' && mainWindow.currentRobot) {
            // 检查机器人是否在线且已注册
            var isRobotReady = false;
            if (typeof robotManager !== 'undefined' && typeof mainWindow !== 'undefined') {
                var robotList = robotManager.getAllRobots();
                for (var i = 0; i < robotList.length; i++) {
                    if (robotList[i].sn === mainWindow.currentRobot && robotList[i].online) {
                        isRobotReady = true;
                        break;
                    }
                }
            }
            
            if (!isRobotReady) {
                console.log("RemoteControlPage: 无法发送RTSP地址请求：机器人 " + mainWindow.currentRobot + " 未在线或未注册")
                // 添加重试机制，等待机器人连接完成
                retryTimer.start()
                return;
            }
            
            // 创建请求RTSP地址的JSON数据包
            var request = {
                "type": "request_rtsp_urls",
                "timestamp": Date.now()
            }
            
            console.log("RemoteControlPage: 发送RTSP地址请求到机器人 " + mainWindow.currentRobot)
            
            // 通过robotManager发送请求
            robotManager.sendControlCommand(mainWindow.currentRobot, request)
        } else {
            console.log("RemoteControlPage: 无法发送RTSP地址请求：robotManager或currentRobot不可用")
        }
    }
    
    // 更新RTSP地址的函数
    function updateRTSPUrls(frontUrl, rearUrl) {
        // 减少不必要的调试输出
        // console.log("RemoteControlPage: 更新RTSP地址，前摄像头：" + frontUrl + "，后摄像头：" + rearUrl);
        
        // 添加调试输出，显示实际使用的RTSP地址
        // console.log("RemoteControlPage: 实际用于前摄像头的RTSP地址: " + frontUrl);
        // console.log("RemoteControlPage: 实际用于后摄像头的RTSP地址: " + rearUrl);
        
        // 更新前摄像头地址
        // console.log("RemoteControlPage: 检查frontLoader.item: " + (frontLoader.item ? "存在" : "不存在"));
        if (frontLoader.item) {
            // console.log("RemoteControlPage: 检查frontLoader.item.player: " + (frontLoader.item.player ? "存在" : "不存在"));
            // 直接设置videoSource属性，让组件内部处理播放器
            // console.log("RemoteControlPage: 设置前摄像头源为 " + frontUrl);
            frontLoader.item.videoSource = frontUrl;
        } else {
            // 减少不必要的警告输出
            // console.warn("RemoteControlPage: 无法访问前摄像头播放器 - item不存在");
        }
        
        // 更新后摄像头地址
        // console.log("RemoteControlPage: 检查rearLoader.item: " + (rearLoader.item ? "存在" : "不存在"));
        if (rearLoader.item) {
            // console.log("RemoteControlPage: 检查rearLoader.item.player: " + (rearLoader.item.player ? "存在" : "不存在"));
            // 直接设置videoSource属性，让组件内部处理播放器
            // console.log("RemoteControlPage: 设置后摄像头源为 " + rearUrl);
            rearLoader.item.videoSource = rearUrl;
        } else {
            // 减少不必要的警告输出
            // console.warn("RemoteControlPage: 无法访问后摄像头播放器 - item不存在");
        }
    }

    // 键盘事件处理
    Keys.onPressed: {
        if (!keysEnabled || !manualMode) return
        
        // 防止键盘自动重复触发 - 只有首次按下才发送指令
        if (event.isAutoRepeat) {
            event.accepted = true
            return
        }
        
        var direction = ""
        switch (event.key) {
            case Qt.Key_W:
                direction = "forward"
                event.accepted = true
                break
            case Qt.Key_S:
                direction = "backward"
                event.accepted = true
                break
            case Qt.Key_A:
                direction = "left"
                event.accepted = true
                break
            case Qt.Key_D:
                direction = "right"
                event.accepted = true
                break
            default:
                return
        }
        
        if (direction !== "") {
            console.log("首次按下按键，发送指令: " + direction)
            sendControlCommand(direction)
        }
    }

    // 键盘释放事件处理 - 松开按键时停止运动
    Keys.onReleased: {
        if (!keysEnabled || !manualMode) return
        
        // 防止键盘自动重复触发 - 只有首次释放才发送停止指令
        if (event.isAutoRepeat) {
            event.accepted = true
            return
        }
        
        var direction = ""
        switch (event.key) {
            case Qt.Key_W:
                direction = "forward"
                event.accepted = true
                break
            case Qt.Key_S:
                direction = "backward"
                event.accepted = true
                break
            case Qt.Key_A:
                direction = "left"
                event.accepted = true
                break
            case Qt.Key_D:
                direction = "right"
                event.accepted = true
                break
            default:
                return
        }
        
        if (direction !== "") {
            // 松开按键时发送停止命令
            console.log("首次释放按键，停止运动: " + direction)
            sendControlCommand("stop")
        }
    }

    // 发送控制命令函数
    /**
     * 紧急停止功能 - 将所有设备置0（控制权限除外）
     * 调用各设备的独立控制函数：
     * - D121: 转向控制置0 (sendSteeringControlCommand)
     * - D122: 行进控制置0 (sendMovementControlCommand)
     * - D123: 发电机启动控制置0 (sendGeneratorControlCommand)
     * - D124: 220V继电器控制置0 (sendRelayControlCommand)
     * - D125: 喷水控制置0 (sendSprayControlCommand)
     * - D126: 制冷自动控制置0 (sendCoolingControlCommand)
     * - D127: 行进速度百分比控制置0 (sendSpeedControlCommand)
     * - D128: 割叶机控制置0 (sendCutterControlCommand)
     * 保留D120控制权限不变
     */
    function sendEmergencyStopCommand() {
        console.log("执行紧急停止：关闭所有设备，保留控制权限")
        
        if (!mainWindow.currentRobot || mainWindow.currentRobot.trim() === "") {
            console.log("错误：未选择机器人，无法执行紧急停止")
            return
        }
        
        if (!robotManager) {
            console.log("错误：RobotManager不可用，无法执行紧急停止")
            return
        }
        
        // 检查是否已经在执行紧急停止
        if (isEmergencyStopping) {
            console.log("紧急停止已在执行中，忽略重复请求")
            return
        }
        
        // 初始化紧急停止状态
        isEmergencyStopping = true
        emergencyStopStep = 0
        
        console.log("开始执行紧急停止：准备调用各设备控制函数（共8步，每步间隔1秒）")
        
        // 开始执行第一步
        executeNextEmergencyStopStep()
    }

    function sendControlCommand(direction) {
        console.log("发送控制命令: " + direction)
        
        // 检查当前机器人是否可用
        if (typeof mainWindow === 'undefined' || !mainWindow.currentRobot) {
            console.log("无法发送控制命令：currentRobot不可用")
            return
        }
        
        // 生成原始Modbus指令并只提取必需字段
        var rawCommands = []
        if (typeof robotManager !== 'undefined' && robotManager.generateRawCommands) {
            var fullCommands = robotManager.generateRawCommands(direction)
            // 只提取下位机需要的三个字段：address、value、functionCode
            for (var i = 0; i < fullCommands.length; i++) {
                var cmd = fullCommands[i]
                rawCommands.push({
                    "address": cmd.address,
                    "value": cmd.value,
                    "functionCode": cmd.functionCode
                })
            }
        }
        
        // 创建精简的JSON格式，只包含下位机必需的字段
        var command = {
            "robot_sn": mainWindow.currentRobot,  // 下位机要求的设备SN字段
            "command": {
                "rawCommands": rawCommands       // 下位机要求的rawCommands数组在command对象内
            }
        }
        
        // 通过robotManager发送命令
        if (typeof robotManager !== 'undefined') {
            // 记录日志（包含完整信息用于调试）
            logControlCommand(command, mainWindow.currentRobot)
            
            // 发送命令到机器人
            robotManager.sendControlCommand(mainWindow.currentRobot, command)
        } else {
            console.log("无法发送控制命令：robotManager不可用")
        }
    }

    // 记录控制命令到日志文件
    function logControlCommand(command, robotSN) {
        // 这里只是示例，实际日志记录需要通过C++端实现
        console.log("记录控制命令到日志: Robot=" + robotSN + ", Command=" + JSON.stringify(command))
    }

    // 连接robotManager的信号，处理RTSP地址响应
    Connections {
        target: typeof robotManager !== 'undefined' ? robotManager : null
        
        onRobotDataReceived: function(sn, data) {
            // 减少不必要的调试输出
            // console.log("RemoteControlPage: 接收到机器人数据，SN: " + sn);
            // console.log("RemoteControlPage: 接收到的数据: " + JSON.stringify(data));
            
            // 检查是否是当前选中的机器人
            if (typeof mainWindow !== 'undefined' && sn === mainWindow.currentRobot) {
                // console.log("RemoteControlPage: 数据来自当前选中的机器人");
                
                // 更新机器人实时数据到mainWindow.currentRobotData
                if (typeof mainWindow !== 'undefined') {
                    if (!mainWindow.currentRobotData) {
                        mainWindow.currentRobotData = {};
                    }
                    
                    // 更新位置信息
                    if (data && data.position) {
                        mainWindow.currentRobotData.position = data.position;
                        console.log("RemoteControlPage: 更新位置信息 - 经度:", data.position.longitude, "纬度:", data.position.latitude);
                    }
                    
                    // 更新温度信息
                    if (data && data.temperature !== undefined) {
                        mainWindow.currentRobotData.temperature = data.temperature;
                        console.log("RemoteControlPage: 更新温度信息 -", data.temperature, "°C");
                    }
                    
                    // 更新电量信息
                    if (data && data.battery !== undefined) {
                        mainWindow.currentRobotData.battery = data.battery;
                        console.log("RemoteControlPage: 更新电量信息 -", data.battery, "%");
                    }
                    
                    // 更新状态信息
                    if (data && data.status) {
                        mainWindow.currentRobotData.status = data.status;
                        console.log("RemoteControlPage: 更新状态信息 -", data.status);
                    }
                }
                
                // 统一处理RTSP地址响应（兼容新旧格式）
                if (data.type === "rtsp_urls" || data.type === "rtsp_urls_response") {
                    // 减少不必要的调试输出
                    // console.log("RemoteControlPage: 接收到RTSP地址响应", JSON.stringify(data));
                    
                    var frontUrl = "";
                    var rearUrl = "";
                    
                    // 处理旧格式的RTSP地址响应
                    if (data.type === "rtsp_urls") {
                        frontUrl = data.front_camera || "rtsp://192.168.126.182:8554/cam1";
                        rearUrl = data.rear_camera || "rtsp://192.168.126.182:8554/cam3";
                        // console.log("RemoteControlPage: 使用旧格式RTSP地址响应");
                        // console.log("RemoteControlPage: 前摄像头地址: " + frontUrl);
                        // console.log("RemoteControlPage: 后摄像头地址: " + rearUrl);
                    }
                    // 处理新格式的RTSP地址响应
                    else if (data.type === "rtsp_urls_response") {
                        // console.log("RemoteControlPage: 使用新格式RTSP地址响应");
                        // 错误处理：检查必要字段
                        if (!data.rtsp_urls || !Array.isArray(data.rtsp_urls) || data.rtsp_urls.length < 1) {
                            // console.warn("RemoteControlPage: RTSP响应数据格式不正确或URL数量不足");
                            return;
                        }
                        
                        // 解析响应数据中的rtsp_urls数组
                        var rtspUrls = data.rtsp_urls;
                        // console.log("RemoteControlPage: 接收到的RTSP URL数组: " + JSON.stringify(rtspUrls));
                        
                        // 使用第一个URL作为前摄像头的视频源
                        frontUrl = rtspUrls[0] || "";
                        
                        // 如果有至少2个URL，使用第二个URL作为后摄像头的视频源
                        if (rtspUrls.length >= 2) {
                            rearUrl = rtspUrls[1] || "";
                        }
                        
                        // console.log("RemoteControlPage: 从响应中提取的前摄像头地址: " + frontUrl);
                        // console.log("RemoteControlPage: 从响应中提取的后摄像头地址: " + rearUrl);
                    }
                    
                    // 更新RTSP地址
                    updateRTSPUrls(frontUrl, rearUrl);
                } else {
                    // 减少不必要的调试输出
                    // console.log("RemoteControlPage: 接收到的数据不是RTSP地址响应，类型: " + data.type);
                }
            } else {
                // 减少不必要的调试输出
                // console.log("RemoteControlPage: 数据不是来自当前选中的机器人，当前机器人: " + (typeof mainWindow !== 'undefined' ? mainWindow.currentRobot : 'undefined'));
            }
        }
    }

    ColumnLayout {
        anchors.fill: parent
        spacing: 16

        // 顶部模式选项卡
        RowLayout {
            spacing: 8
            Layout.alignment: Qt.AlignLeft
            Layout.preferredHeight: 90

            Button {
                id: autoModeBtn
                text: "参数预设自动运行"
                checkable: true
                checked: !manualMode
                onClicked: {
                    manualMode = false
                    keysEnabled = false
                }
                background: Rectangle {
                    radius: 6
                    color: autoModeBtn.checked ? "white" : "#eef2f5"
                    border.color: autoModeBtn.checked ? "#0A3D62" : "transparent"
                    border.width: autoModeBtn.checked ? 2 : 0
                }
                contentItem: Text {
                    text: autoModeBtn.text
                    color: autoModeBtn.checked ? "#0A3D62" : "#2c3e50"
                    font.pixelSize: 14
                    horizontalAlignment: Text.AlignHCenter
                    verticalAlignment: Text.AlignVCenter
                    elide: Text.ElideRight
                }
            }

            Button {
                id: manualModeBtn
                text: "远程手动控制"
                checkable: true
                checked: manualMode
                onClicked: {
                    manualMode = true
                    keysEnabled = true
                    // 设置焦点以接收键盘事件
                    remoteControlPage.forceActiveFocus()
                }
                background: Rectangle {
                    radius: 6
                    color: manualModeBtn.checked ? "white" : "#eef2f5"
                    border.color: manualModeBtn.checked ? "#0A3D62" : "transparent"
                    border.width: manualModeBtn.checked ? 2 : 0
                }
                contentItem: Text {
                    text: manualModeBtn.text
                    color: manualModeBtn.checked ? "#0A3D62" : "#2c3e50"
                    font.pixelSize: 14
                    horizontalAlignment: Text.AlignHCenter
                    verticalAlignment: Text.AlignVCenter
                    elide: Text.ElideRight
                }
            }
        }

        // 监控区（双摄像头）
        GridLayout {
            columns: 2
            columnSpacing: 16
            rowSpacing: 16
            Layout.fillWidth: true
            Layout.preferredHeight: 500

            // 左：前摄像头
            Loader {
                id: frontLoader
                sourceComponent: cameraPanel
                onLoaded: {
                    item.title = "前摄像头监控画面"
                    // 设置前摄像头RTSP流地址为初始空值，等待从机器人获取实际地址
                    item.videoSource = ""
                    if (item.clicked) item.clicked.connect(function(){ focusedCamera = (focusedCamera === "front" ? "" : "front") })
                }
                Layout.fillWidth: true
                Layout.preferredHeight: focusedCamera === "front" ? 500 : 390
                Layout.columnSpan: focusedCamera === "front" ? 2 : 1
                visible: focusedCamera !== "rear"
            }

            // 右：后摄像头
            Loader {
                id: rearLoader
                sourceComponent: cameraPanel
                onLoaded: {
                    item.title = "后摄像头监控画面"
                    // 设置后摄像头RTSP流地址为初始空值，等待从机器人获取实际地址
                    item.videoSource = ""
                    if (item.clicked) item.clicked.connect(function(){ focusedCamera = (focusedCamera === "rear" ? "" : "rear") })
                }
                Layout.fillWidth: true
                Layout.preferredHeight: focusedCamera === "rear" ? 500 : 390
                Layout.columnSpan: focusedCamera === "rear" ? 2 : 1
                visible: focusedCamera !== "front"
            }
        }

        // 控制区

        // 控制区
        Rectangle {
            color: "white"
            radius: 8
            Layout.fillWidth: true
            Layout.preferredHeight: 320
            layer.enabled: true
            layer.effect: DropShadow {
                horizontalOffset: 0
                verticalOffset: 2
                radius: 8
                samples: 16
                color: "#20000000"
            }

            Loader {
                id: panelLoader
                anchors.fill: parent
                anchors.margins: 16
                sourceComponent: manualMode ? manualPanel : autoPanel
            }
        }
    }

    // 自动运行参数预设面板
    Component {
        id: autoPanel
        ColumnLayout {
            spacing: 16

            Label {
                text: "参数预设设置"
                font.pixelSize: 18
                font.bold: true
                color: "#2c3e50"
            }

            GridLayout {
                columns: 2
                columnSpacing: 16
                rowSpacing: 16
                Layout.fillWidth: true
                Layout.fillHeight: true

                // 左列
                ColumnLayout {
                    spacing: 16
                    Layout.fillWidth: true

                    // 预设作业模式
                    ColumnLayout {
                        spacing: 6
                        Label { text: "预设作业模式"; color: "#34495e"; font.pixelSize: 12 }
                        ComboBox {
                            model: ["标准平地作业", "坡地作业", "复杂地形作业", "精细作业模式", "快速作业模式"]
                            Layout.fillWidth: true
                        }
                    }

                    // 作业速度
                    ColumnLayout {
                        spacing: 6
                        Label { text: "作业速度"; color: "#34495e"; font.pixelSize: 12 }
                        Slider { id: speedSlider; from: 0; to: 3; stepSize: 0.1; value: 1.2; Layout.fillWidth: true }
                        RowLayout {
                            Layout.fillWidth: true
                            Label { text: "0 m/s"; color: "#7f8c8d"; font.pixelSize: 11 }
                            Item { Layout.fillWidth: true }
                            Label { text: "当前: " + speedSlider.value.toFixed(1) + " m/s"; color: "#7f8c8d"; font.pixelSize: 11 }
                            Item { Layout.fillWidth: true }
                            Label { text: "3 m/s"; color: "#7f8c8d"; font.pixelSize: 11 }
                        }
                    }

                    // 作业深度
                    ColumnLayout {
                        spacing: 6
                        Label { text: "作业深度"; color: "#34495e"; font.pixelSize: 12 }
                        Slider { id: depthSlider; from: 0; to: 50; stepSize: 1; value: 25; Layout.fillWidth: true }
                        RowLayout {
                            Layout.fillWidth: true
                            Label { text: "0 cm"; color: "#7f8c8d"; font.pixelSize: 11 }
                            Item { Layout.fillWidth: true }
                            Label { text: "当前: " + depthSlider.value.toFixed(0) + " cm"; color: "#7f8c8d"; font.pixelSize: 11 }
                            Item { Layout.fillWidth: true }
                            Label { text: "50 cm"; color: "#7f8c8d"; font.pixelSize: 11 }
                        }
                    }
                }

                // 右列
                ColumnLayout {
                    spacing: 16
                    Layout.fillWidth: true

                    // 路径规划
                    ColumnLayout {
                        spacing: 6
                        Label { text: "路径规划"; color: "#34495e"; font.pixelSize: 12 }
                        GridLayout {
                            id: routesGrid
                            columns: 4
                            columnSpacing: 12
                            rowSpacing: 0
                            Layout.fillWidth: true

                            // 单选索引，-1 表示未选
                            property int selectedIndex: -1
                            function applySelection() {
                                if (btn1.item) btn1.item.color = (selectedIndex === 0 ? "#60A3BC" : "transparent")
                                if (btn2.item) btn2.item.color = (selectedIndex === 1 ? "#60A3BC" : "transparent")
                                if (btn3.item) btn3.item.color = (selectedIndex === 2 ? "#60A3BC" : "transparent")
                                if (btn4.item) btn4.item.color = (selectedIndex === 3 ? "#60A3BC" : "transparent")
                            }

                            Loader {
                                id: btn1
                                sourceComponent: routeButton
                                onLoaded: {
                                    item.text = "直线模式"
                                    item.color = routesGrid.selectedIndex === 0 ? "#60A3BC" : "transparent"
                                    item.clicked.connect(function(){ routesGrid.selectedIndex = 0; routesGrid.applySelection() })
                                }
                                Layout.fillWidth: true
                                Layout.preferredHeight: 44
                            }
                            Loader {
                                id: btn2
                                sourceComponent: routeButton
                                onLoaded: {
                                    item.text = "往返模式"
                                    item.color = routesGrid.selectedIndex === 1 ? "#60A3BC" : "transparent"
                                    item.clicked.connect(function(){ routesGrid.selectedIndex = 1; routesGrid.applySelection() })
                                }
                                Layout.fillWidth: true
                                Layout.preferredHeight: 44
                            }
                            Loader {
                                id: btn3
                                sourceComponent: routeButton
                                onLoaded: {
                                    item.text = "螺旋模式"
                                    item.color = routesGrid.selectedIndex === 2 ? "#60A3BC" : "transparent"
                                    item.clicked.connect(function(){ routesGrid.selectedIndex = 2; routesGrid.applySelection() })
                                }
                                Layout.fillWidth: true
                                Layout.preferredHeight: 44
                            }
                            Loader {
                                id: btn4
                                sourceComponent: routeButton
                                onLoaded: {
                                    item.text = "自定义路径"
                                    item.color = routesGrid.selectedIndex === 3 ? "#60A3BC" : "transparent"
                                    item.clicked.connect(function(){ routesGrid.selectedIndex = 3; routesGrid.applySelection() })
                                }
                                Layout.fillWidth: true
                                Layout.preferredHeight: 44
                            }
                        }
                    }

                    // 作业时间设置
                    ColumnLayout {
                        spacing: 6
                        Label { text: "作业时间设置"; color: "#34495e"; font.pixelSize: 12 }
                        GridLayout {
                            columns: 2
                            columnSpacing: 8
                            rowSpacing: 8
                            Layout.fillWidth: true
                            ColumnLayout {
                                Label { text: "开始时间"; color: "#7f8c8d"; font.pixelSize: 11 }
                                TextField { placeholderText: "yyyy/mm/dd --:--"; Layout.fillWidth: true }
                            }
                            ColumnLayout {
                                Label { text: "结束时间"; color: "#7f8c8d"; font.pixelSize: 11 }
                                TextField { placeholderText: "yyyy/mm/dd --:--"; Layout.fillWidth: true }
                            }
                        }
                    }

                    // 操作按钮
                    RowLayout {
                        Layout.fillWidth: true
                        spacing: 8
                        Button {
                            text: "启动自动作业"
                            Layout.fillWidth: true
                            background: Rectangle { color: "#2ECC71"; radius: 6 }
                            contentItem: Text { text: "启动自动作业"; color: "white"; horizontalAlignment: Text.AlignHCenter; verticalAlignment: Text.AlignVCenter }
                            Layout.preferredHeight: 44
                        }
                        ColumnLayout {
                            spacing: 8
                            Layout.fillWidth: true
                            Button {
                                text: "保存预设"
                                Layout.fillWidth: true
                                background: Rectangle { color: "#e0e0e0"; radius: 6 }
                                contentItem: Text { text: "保存预设"; color: "#333"; horizontalAlignment: Text.AlignHCenter; verticalAlignment: Text.AlignVCenter }
                                Layout.preferredHeight: 30
                            }
                            Button {
                                text: "重置"
                                Layout.fillWidth: true
                                background: Rectangle { color: "#e0e0e0"; radius: 6 }
                                contentItem: Text { text: "重置"; color: "#333"; horizontalAlignment: Text.AlignHCenter; verticalAlignment: Text.AlignVCenter }
                                Layout.preferredHeight: 30
                            }
                        }
                    }
                }
            }
        }
    }

    // 手动控制面板
    Component {
        id: manualPanel
        ColumnLayout {
            spacing: 16
            Label {
                text: "手动控制"
                font.pixelSize: 18
                font.bold: true
                color: "#2c3e50"
            }

            // 已移除方向控制与方向辅助控制

            // 速度与功能控制
            ColumnLayout {
                spacing: 16

                // 行驶速度
                ColumnLayout {
                    spacing: 6
                    Label { text: "行驶速度控制 (0-50)"; color: "#34495e"; font.pixelSize: 12 }
                    Slider { 
                        id: driveSpeed; 
                        from: 0; 
                        to: 50; 
                        stepSize: 1; 
                        value: 0; 
                        Layout.fillWidth: true
                        onValueChanged: {
                            sendSpeedControlCommand(driveSpeed.value)
                        }
                    }
                    RowLayout {
                        Layout.fillWidth: true
                        Label { text: "停止"; color: "#7f8c8d"; font.pixelSize: 11 }
                        Item { Layout.fillWidth: true }
                        Label { text: "当前: " + driveSpeed.value.toFixed(0) + " %"; color: "#7f8c8d"; font.pixelSize: 11 }
                        Item { Layout.fillWidth: true }
                        Label { text: "最大"; color: "#7f8c8d"; font.pixelSize: 11 }
                    }
                }

                // 功能控制按钮 - 单行独立按钮模式
                RowLayout {
                    spacing: 12
                    Layout.fillWidth: true
                    
                    // 启动作业装置按钮
                    Button {
                        id: controlBtn1
                        Layout.fillWidth: true
                        Layout.preferredHeight: 44
                        property bool isSelected: false
                        text: "启动作业装置"
                        
                        background: Rectangle {
                            color: controlBtn1.isSelected ? "#60A3BC" : "#e0e0e0"
                            radius: 6
                            border.color: controlBtn1.isSelected ? "#4A90A4" : "#b0b0b0"
                            border.width: 1
                        }
                        
                        contentItem: Text {
                            text: controlBtn1.text
                            color: controlBtn1.isSelected ? "white" : "#333"
                            horizontalAlignment: Text.AlignHCenter
                            verticalAlignment: Text.AlignVCenter
                            font.pixelSize: 12
                            font.bold: false
                        }
                        
                        onClicked: {
                            console.log("用户点击启动作业装置按钮")
                            controlBtn1.isSelected = !controlBtn1.isSelected
                            sendControlCommand("start_operation")
                        }
                    }
                    
                    // 停止作业装置按钮
                    Button {
                        id: controlBtn2
                        Layout.fillWidth: true
                        Layout.preferredHeight: 44
                        property bool isSelected: false
                        text: "停止作业装置"
                        
                        background: Rectangle {
                            color: controlBtn2.isSelected ? "#60A3BC" : "#e0e0e0"
                            radius: 6
                            border.color: controlBtn2.isSelected ? "#4A90A4" : "#b0b0b0"
                            border.width: 1
                        }
                        
                        contentItem: Text {
                            text: controlBtn2.text
                            color: controlBtn2.isSelected ? "white" : "#333"
                            horizontalAlignment: Text.AlignHCenter
                            verticalAlignment: Text.AlignVCenter
                            font.pixelSize: 12
                            font.bold: false
                        }
                        
                        onClicked: {
                            console.log("用户点击停止作业装置按钮")
                            controlBtn2.isSelected = !controlBtn2.isSelected
                            sendControlCommand("stop_operation")
                        }
                    }
                    
                    // 拍照取证按钮
                    Button {
                        id: controlBtn3
                        Layout.fillWidth: true
                        Layout.preferredHeight: 44
                        property bool isSelected: false
                        text: "拍照取证"
                        
                        background: Rectangle {
                            color: controlBtn3.isSelected ? "#60A3BC" : "#e0e0e0"
                            radius: 6
                            border.color: controlBtn3.isSelected ? "#4A90A4" : "#b0b0b0"
                            border.width: 1
                        }
                        
                        contentItem: Text {
                            text: controlBtn3.text
                            color: controlBtn3.isSelected ? "white" : "#333"
                            horizontalAlignment: Text.AlignHCenter
                            verticalAlignment: Text.AlignVCenter
                            font.pixelSize: 12
                            font.bold: false
                        }
                        
                        onClicked: {
                            console.log("用户点击拍照取证按钮")
                            controlBtn3.isSelected = !controlBtn3.isSelected
                            sendControlCommand("take_photo")
                        }
                    }
                    
                    // 语音指令按钮
                    Button {
                        id: controlBtn4
                        Layout.fillWidth: true
                        Layout.preferredHeight: 44
                        property bool isSelected: false
                        text: "语音指令"
                        
                        background: Rectangle {
                            color: controlBtn4.isSelected ? "#60A3BC" : "#e0e0e0"
                            radius: 6
                            border.color: controlBtn4.isSelected ? "#4A90A4" : "#b0b0b0"
                            border.width: 1
                        }
                        
                        contentItem: Text {
                            text: controlBtn4.text
                            color: controlBtn4.isSelected ? "white" : "#333"
                            horizontalAlignment: Text.AlignHCenter
                            verticalAlignment: Text.AlignVCenter
                            font.pixelSize: 12
                            font.bold: false
                        }
                        
                        onClicked: {
                            console.log("用户点击语音指令按钮")
                            controlBtn4.isSelected = !controlBtn4.isSelected
                            sendControlCommand("voice_command")
                        }
                    }
                    
                    // 继电器控制按钮（切换模式）
                     Button {
                         id: controlBtn5
                         Layout.fillWidth: true
                         Layout.preferredHeight: 44
                         property bool relayOn: false  // 继电器状态
                         text: relayOn ? "继电器关闭" : "继电器开启"
                         
                         background: Rectangle {
                             color: controlBtn5.relayOn ? "#60A3BC" : "#e0e0e0"
                             radius: 6
                             border.color: controlBtn5.relayOn ? "#4A90A4" : "#b0b0b0"
                             border.width: 1
                         }
                         
                         contentItem: Text {
                             text: controlBtn5.text
                             color: controlBtn5.relayOn ? "white" : "#333"
                             horizontalAlignment: Text.AlignHCenter
                             verticalAlignment: Text.AlignVCenter
                             font.pixelSize: 12
                             font.bold: false
                         }
                         
                         onClicked: {
                             console.log("用户点击继电器控制按钮，当前状态：" + (controlBtn5.relayOn ? "开启" : "关闭"))
                             
                             // 切换继电器状态
                             controlBtn5.relayOn = !controlBtn5.relayOn
                             
                             // 发送对应指令
                             if (controlBtn5.relayOn) {
                                 sendRelayControlCommand(1)  // 开启继电器
                             } else {
                                 sendRelayControlCommand(0)  // 关闭继电器
                             }
                         }
                     }
                }

                // 平台遥控控制按钮
                RowLayout {
                    Layout.fillWidth: true
                    spacing: 12
                    
                    Button {
                        text: "平台遥控模式"
                        Layout.fillWidth: true
                        background: Rectangle { 
                            color: "#3498DB" 
                            radius: 6
                            border.color: "#2980B9"
                            border.width: 1
                        }
                        contentItem: Text { 
                            text: "🔧 平台遥控模式" 
                            color: "white" 
                            horizontalAlignment: Text.AlignHCenter
                            verticalAlignment: Text.AlignVCenter
                            font.pixelSize: 14
                            font.bold: true
                        }
                        Layout.preferredHeight: 44
                        onClicked: {
                            console.log("用户点击平台遥控模式按钮")
                            sendPlatformRemoteModeCommand(1)
                        }
                    }
                    
                    Button {
                        text: "平台遥控权限释放"
                        Layout.fillWidth: true
                        background: Rectangle { 
                            color: "#95A5A6" 
                            radius: 6
                            border.color: "#7F8C8D"
                            border.width: 1
                        }
                        contentItem: Text { 
                            text: "🔓 权限释放" 
                            color: "white" 
                            horizontalAlignment: Text.AlignHCenter
                            verticalAlignment: Text.AlignVCenter
                            font.pixelSize: 14
                            font.bold: true
                        }
                        Layout.preferredHeight: 44
                        onClicked: {
                            console.log("用户点击平台遥控权限释放按钮")
                            sendPlatformRemoteReleaseCommand()
                        }
                    }
                }

                // 紧急停止
                Button {
                    text: "紧急停止"
                    Layout.fillWidth: true
                    background: Rectangle { color: "#E74C3C"; radius: 6 }
                    contentItem: Text { text: "⚠ 紧急停止"; color: "white"; horizontalAlignment: Text.AlignHCenter; verticalAlignment: Text.AlignVCenter; font.pixelSize: 16 }
                    Layout.preferredHeight: 48
                    
                    // 紧急停止事件处理 - 将所有设备置0（控制权限除外）
                    onClicked: {
                        console.log("用户点击紧急停止按钮，执行紧急停止功能")
                        // 调用紧急停止函数，关闭所有设备但保留控制权限
                        sendEmergencyStopCommand()
                    }
                }
            }
        }
    }

    // 相机面板组件 - 优化版
    Component {
        id: cameraPanel
        Rectangle {
            id: cameraCard
            property string title: ""
            property url videoSource: ""
            signal clicked()
            color: "white"
            radius: 8
            Layout.fillWidth: true
            Layout.preferredHeight: 260

            ColumnLayout {
                anchors.fill: parent
                spacing: 8
                Label { 
                    text: title
                    color: "#2c3e50"
                    font.bold: true
                    Layout.leftMargin: 12
                    Layout.topMargin: 12
                }
                
                Rectangle {
                    id: videoContainer
                    Layout.fillWidth: true
                    Layout.fillHeight: true
                    Layout.minimumHeight: 330
                    color: "#222"
                    radius: 8
                    anchors.margins: 8
                    clip: true
                    
                    // 重新连接尝试计数
                    property int reconnectAttempts: 0
                    property int maxReconnectAttempts: 5
                    
                    // 控制加载指示器显示的属性
                    property bool shouldShowIndicator: false
                    
                    // 视频播放器组件 - 优化版
                    MediaPlayer {
                        id: player
                        source: videoSource
                        autoPlay: true
                        loops: MediaPlayer.Infinite
                        
                        // 优化设置以减少延迟并启用硬件加速
                        property var options: QtObject {
                            property int bufferSize: 1024 * 1024  // 1MB缓冲，避免过小导致频繁重载
                            property bool lowLatency: false  // 关闭低延迟模式，提高稳定性
                            property string rtspTransport: "tcp"  // 使用TCP传输
                            property int networkCache: 5000  // 网络缓存5秒
                            property int playbackRate: 1.0  // 正常播放速率
                        }
                        
                        // 错误处理
                        onError: {
                            console.log("视频播放错误 [" + title + "]: " + errorString + " (" + source + ")")
                            // 限制重连频率，避免过于频繁的重连
                            if (videoContainer.reconnectAttempts < videoContainer.maxReconnectAttempts) {
                                // 增加重连间隔时间
                                reconnectTimer.interval = Math.min(reconnectTimer.interval * 2, 120000)  // 最大2分钟
                                reconnectTimer.restart()
                            }
                        }
                        
                        // 连接状态处理
                        onStatusChanged: {
                            if (status === MediaPlayer.Loaded) {
                                console.log("视频流已加载 [" + title + "]: " + source)
                                videoContainer.reconnectAttempts = 0
                                // 重置重连间隔
                                reconnectTimer.interval = 30000  // 增加到30秒
                                // 如果已经加载完成，检查播放状态
                                if (playbackState === MediaPlayer.PlayingState) {
                                    videoContainer.shouldShowIndicator = false
                                }
                            } else if (status === MediaPlayer.Buffering) {
                                console.log("视频流缓冲中 [" + title + "]: " + source)
                                videoContainer.shouldShowIndicator = true
                                // 缓冲时给予更多时间，不立即重连
                                if (bufferProgress > 0.8) {
                                    // 缓冲进度超过80%，给予更多耐心
                                    return
                                }
                            } else if (status === MediaPlayer.Stalled) {
                                console.log("视频流卡顿 [" + title + "]: " + source)
                                // 卡顿时不立即重连，先等待一段时间
                                videoContainer.shouldShowIndicator = true
                                if (videoContainer.reconnectAttempts < videoContainer.maxReconnectAttempts) {
                                    // 增加重连间隔时间到60秒
                                    reconnectTimer.interval = Math.min(reconnectTimer.interval * 2, 180000)  // 最大3分钟
                                    reconnectTimer.restart()
                                }
                            } else if (status === MediaPlayer.EndOfMedia) {
                                console.log("视频流结束，重新播放 [" + title + "]: " + source)
                                videoContainer.shouldShowIndicator = true
                                // 延迟重新播放，避免立即循环
                                restartTimer.restart()
                            } else if (status === MediaPlayer.Invalid) {
                                console.log("视频流无效 [" + title + "]: " + source)
                                // 尝试重新连接，但限制频率
                                videoContainer.shouldShowIndicator = true
                                if (videoContainer.reconnectAttempts < videoContainer.maxReconnectAttempts) {
                                    // 增加重连间隔时间
                                    reconnectTimer.interval = Math.min(reconnectTimer.interval * 2, 180000)  // 最大3分钟
                                    reconnectTimer.restart()
                                }
                            }
                        }

                        // 播放状态处理
                        onPlaybackStateChanged: {
                            if (playbackState === MediaPlayer.PlayingState) {
                                console.log("视频流开始播放 [" + title + "]: " + source)
                                // 确保隐藏加载指示器
                                videoContainer.shouldShowIndicator = false
                                // 重置错误计数
                                videoContainer.reconnectAttempts = 0
                            } else if (playbackState === MediaPlayer.PausedState) {
                                console.log("视频流暂停播放 [" + title + "]: " + source)
                            } else if (playbackState === MediaPlayer.StoppedState) {
                                console.log("视频流停止播放 [" + title + "]: " + source)
                                // 检查是否是异常停止（非用户操作）
                                if (status !== MediaPlayer.EndOfMedia && status !== MediaPlayer.Invalid) {
                                    console.log("检测到异常停止，准备重连 [" + title + "]")
                                    if (videoContainer.reconnectAttempts < videoContainer.maxReconnectAttempts) {
                                        reconnectTimer.restart()
                                    }
                                }
                            }
                        }
                        
                        // 添加属性变化监听器，监控source属性变化
                        onSourceChanged: {
                            console.log("MediaPlayer source changed [" + title + "]: " + source)
                            // 当source改变时，自动播放
                            if (source !== "") {
                                // 重置重连计数
                                videoContainer.reconnectAttempts = 0
                                // 重置重连间隔
                                reconnectTimer.interval = 15000
                                play()
                            }
                        }
                    }
                    
                    // 重新连接定时器
                    Timer {
                        id: reconnectTimer
                        // 增加重连间隔，避免过于频繁的重连
                        interval: 30000  // 30秒后重试（增加间隔）
                        repeat: false
                        onTriggered: {
                            if (videoContainer.reconnectAttempts < videoContainer.maxReconnectAttempts) {
                                console.log("尝试重新连接 [" + title + "] (尝试 " + (videoContainer.reconnectAttempts + 1) + "/" + videoContainer.maxReconnectAttempts + ")")
                                videoContainer.reconnectAttempts++
                                videoContainer.shouldShowIndicator = true
                                stop()
                                play()
                            } else {
                                console.log("达到最大重新连接尝试次数 [" + title + "]")
                            }
                        }
                    }
                    
                    // 重启定时器 - 用于延迟重启
                    Timer {
                        id: restartTimer
                        interval: 5000  // 5秒后重启
                        repeat: false
                        onTriggered: {
                            console.log("延迟重启视频流 [" + title + "]: " + player.source)
                            player.stop()
                            player.play()
                        }
                    }

                    VideoOutput {
                        anchors.fill: parent
                        source: player
                        fillMode: VideoOutput.PreserveAspectFit
                        
                        // 优化渲染性能
                        smooth: false
                        antialiasing: false
                    }
                    
                    MouseArea { 
                        anchors.fill: parent
                        onClicked: cameraCard.clicked()
                        
                        // 添加重新加载功能
                        onDoubleClicked: {
                            console.log("重新加载视频流 [" + title + "]: " + player.source)
                            videoContainer.reconnectAttempts = 0
                            player.stop()
                            player.play()
                        }
                    }

                }
            }
        }
    }

    // 路径按钮组件
    Component {
        id: routeButton
        Rectangle {
            property alias text: label.text
            signal clicked()
            color: "transparent"
            border.color: "#e0e0e0"
            radius: 6
            Layout.fillWidth: true
            Layout.preferredHeight: 44
            MouseArea { anchors.fill: parent; onClicked: parent.clicked() }
            RowLayout { anchors.fill: parent; anchors.margins: 10; Label { id: label; color: "#555"; font.pixelSize: 12 } }
        }
    }

    // 圆形控制按钮
    Component {
        id: controlCircle
        Rectangle {
            property string iconChar: "↑"
            property string circleColor: "#0A3D62"
            property string textColor: "white"
            width: 44; height: 44; radius: 22
            color: circleColor
            RowLayout { anchors.fill: parent; Label { text: iconChar; color: textColor; font.bold: true; Layout.alignment: Qt.AlignHCenter | Qt.AlignVCenter } }
            MouseArea { anchors.fill: parent }
        }
    }

    // 功能控制按钮组件
    Component {
        id: controlButton
        Button {
            property string colorHex: "#e0e0e0"
            property string textColor: "#333"
            text: "按钮"
            
            background: Rectangle { 
                id: bgRect
                color: colorHex; 
                radius: 6 
                // 添加属性变化监听器
                onColorChanged: {
                    color = colorHex
                }
            }
            
            contentItem: Text { 
                id: textItem
                text: parent.text; 
                color: textColor; 
                horizontalAlignment: Text.AlignHCenter; 
                verticalAlignment: Text.AlignVCenter 
                // 添加属性变化监听器
                onColorChanged: {
                    color = textColor
                }
            }
            
            Layout.fillWidth: true
            Layout.preferredHeight: 44
            
            // 初始化时确保样式正确应用
            Component.onCompleted: {
                bgRect.color = colorHex
                textItem.color = textColor
            }
        }
    }
}